A Peptides Prediction Methodology for Tertiary Structure Based on Simulated Annealing

Abstract

The Protein Folding Problem (PFP) is a big challenge that has remained unsolved for more than fifty years. This problem consists of obtaining the tertiary structure or Native Structure (NS) of a protein knowing its amino acid sequence. The computational methodologies applied to this problem are classified into two groups, known as Template-Based Modeling (TBM) and ab initio models. In the latter methodology, only information from the primary structure of the target protein is used. In the literature, Hybrid Simulated Annealing (HSA) algorithms are among the best ab initio algorithms for PFP; Golden Ratio Simulated Annealing (GRSA) is a PFP family of these algorithms designed for peptides. Moreover, for the algorithms designed with TBM, they use information from a target protein’s primary structure and information from similar or analog proteins. This paper presents GRSA-SSP methodology that implements a secondary structure prediction to build an initial model and refine it with HSA algorithms. Additionally, we compare the performance of the GRSAX-SSP algorithms versus its corresponding GRSAX. Finally, our best algorithm GRSAX-SSP is compared with PEP-FOLD3, I-TASSER, QUARK, and Rosetta, showing that it competes in small peptides except when predicting the largest peptides.

1. Introduction

Proteins or polypeptides are macromolecules built from amino acids (aa) and are mainly responsible for living beings’ functionality. Proteins are essentials elements because every protein has a specific function related to its unique three-dimensional structure named Native Structure (NS). All the proteins consist of a polymer chain of aa; the junctions with a small number of them are named peptides. The peptides have significant importance in the science community because of their multiple applications, for instance, in pharmaceutical research [1,2,3,4], drug design [5,6,7], diagnosis [8,9,10], and therapy [11,12]. To obtain the NS of proteins from an amino acid sequence could bring benefits to human beings.

The PFP has been identified as an important problem since Kendrew and Perutz’s research teams obtained the myoglobin and hemoglobin molecules’ tertiary structure, respectively [13,14]. These studies established the relation between function and structure. PFP consists of obtaining the three-dimensional structure of a protein with the lowest Gibbs free energy, thermodynamically stable three-dimensional conformation [15].

The PFP is considered an NP-hard problem [16]. Thus, presumably, none of the known exact algorithms can solve it in polynomial time. In other words, the execution time grows exponentially when using them. In contrast, any protein passes from the aa sequence to its NS three-dimensional structure very rapidly in nature. The latter issue is known as the Levinthal Paradox [17].

Several algorithms have been applied to solve the PFP successfully, and one of the most effective algorithms has been the Simulated Annealing algorithm (SA). The SA is commonly hybridized with other methods; the combination algorithms are called Hybrid Simulated Annealing algorithms (HSA). These algorithms successfully applied to peptides are the following:

(a)

The classical Monte Carlo Method, or SA, was applied to the PFP [18,19]. Additionally, an analytical tuning method to SA was proposed [20].

(b)

Golden Ratio Simulated Annealing (GRSA) family: Original GRSA proposing a cooling strategy [21], Evolutionary Golden Ratio SA (EGRSA) using genetic operators [22], and GRSA2, which is hybridization with the GRSA and Chemical Reaction Optimization algorithm (CRO) [23].

(c)

Metropolis and multiobjective optimization methods were applied in the previous CASP competitions. The approaches that traditionally have obtained the best results were Rossetta [24], QUARK [25], and I-TASSER [26]. However, deep learning applied by the Alphafold algorithm [27] achieved the best score in the CASP13 and CASP14.

(d)

PEP-FOLD3 algorithm, which uses secondary structure information and a Monte Carlo method, and is very successful for small peptides (5 to 50 aa) [28].

The HSA algorithms previously mentioned obtained excellent results for small proteins or peptides. However, when the number of aa increases, the variables (torsional angle of aa) are also increased, the computational time for exploring the solution space is considerable. As a result, the PFP area needs new approaches to obtaining better solutions for large peptides or proteins.

This paper proposes the methodology GRSA-SSP that combines GRSA algorithms with the Secondary Structure Prediction (SSP). For a given chain of aa representing a peptide or a protein, the GRSA-SSP performs two processes:

(a)

To obtain the first protein prediction from the secondary structure of the amino-acids sequence.

(b)

To refine the previous protein prediction by using GRSA family algorithms.

These two processes are performed in several steps described in this paper. The algorithms used in the second phase of GRSA-SSP can be one of the GRSA family algorithms. This paper named these hybrid algorithms GRSAX-SSP, where X is used to distinguish the GRSA algorithm. We evaluate our methodology using RMSD and TM-score metrics [29]. Additionally, experimentation is performed with a set of forty-five instances of peptides and a set of six mini proteins, which are compared with the most popular algorithms in the literature, such as PEP-FOLD3 [28], I-TASSER [30,31], Rosetta [24,32], and QUARK [25,33].

The paper’s organization is as follows: first, we present the introduction to PFP and HSA algorithms. Then, in the Background section, we review the Protein Folding Problem definition and some relevant research in the literature, and we explain the GRSA family of algorithms. In the next section, we describe the GRSA-SSP methodology. In the Results section, we present experimentation comparing the GRSA algorithms with those of the literature; also, we analyze the presented methodology’s performance. Finally, the conclusions of this research are presented.

2. Background

The PFP is a significant multidisciplinary problem that has been investigated for over half a century [34]. Different scientific areas have been studied, for example, computer science, bioinformatics, and molecular biology, concerning this problem, and three questions in particular need to be answered [34].

• Which is the physical code in which an amino-acids sequence dictates an NS?
• Why in nature do proteins fold very quickly while in silicon they fold relatively slower?
• Is there an algorithm that predicts the protein structure from the amino-acids sequence?

This paper is related to the last question. We propose different strategies to obtain the NS tertiary structure using GRSA family algorithms and secondary structure prediction. As we mentioned before, finding new algorithms for PFP is significant not only because of its potential applications but also because it is an NP-hard problem [16], and the number of combinations that determine which algorithms must be explored in a very large solution space.

2.1. Definition of Ab-Initio and Force Fields

The ab initio modeling can be defined as an optimization problem where the Gibbs free energy is the objective function f(n), and this has to be minimized. Thus, this problem is defined as follows: let there be a sequence of amino acids: n = a1, a2, …, an; every amino acid has associated with it a set of angles σ1, σ2, …, σm where m represents a particular dihedral angle; then, minimizing the energy function f(σ|1, σ2, …, σm) provides the best tertiary structure or NS. The energy functions (force fields) are used for determining the energy of a protein structure [35], and some examples of these are AMBER [36], CHARMM [37], ECEPP/2, and ECEPP/3 [38]. The potential energy of ECEPP/2 is given by Equation (1), which is calculated in vacuo for only intramolecular energies, and this is the energy function to be minimized [39].

$$E_{total}={\displaystyle \sum }_{j>i}\left(\frac{A_{ij}}{r_{ij}^{12}}-\frac{B_{ij}}{r_{ij}{}^6}\right)+332{\displaystyle \sum }_{j>i}\frac{q_i{q}_j}{\epsilon r_{ij}}+{\displaystyle \sum }_{j>i}\left(\frac{C_{ij}}{r_{ij}^{12}}-\frac{D_{ij}}{r_{ij}{}^{10}}\right)+{\displaystyle \sum }_n{U}_n\left(1\pm cos\left(k_n{\phi }_n\right)\right)$$

(1)

where: r_ij is the distance in Å (angstroms) between the atoms i and j; A_ij, B_ij, C_ij, and D_ij are the parameters of the empirical potentials; q_i and q_j are the partial charges in the atoms i and j, respectively; ε is the dielectric constant; U_n is the energetic torsion barrier of rotation about the bond n; k_n is the multiplicity of the torsion angle φ_n.

In this paper, we use the potential energy of ECEPP/2 as an objective function because we explore the conformational space, and when the energy of the protein structure is minimized, then the protein structure is accepted.

2.2. Computational Approaches for PFP

The CASP organization has classified PFP models into two main groups:

Group 1: Template-based modeling (TBM). In this group, we find algorithms that use biological information obtained from the secondary structure of the target protein, homology, and fragments of other proteins. These algorithms have achieved good results for predicting protein structures in the CASP [32,40,41]. TBM involves several strategies; some of the most common are homology [42,43], threading [44], and fragment assembly [30,45].

Group 2: Ab initio. This prediction approach classically refers to the determination of the NS using only the aa sequence information. Unfortunately, ab initio algorithms have achieved good PFP results but only for small proteins with less than 120 residues [46]. The Ab initio modeling is the most challenging approach because it uses the amino acids’ sequence as unique information. Finding an optimal solution with ab initio is very difficult for big proteins because the solution space is enormous.

These two groups can be applied to small proteins or peptides (between 5 to 50 aa) [28,47]. There are successful studies applied to protein prediction using SA [48,49,50] or Monte Carlo algorithms with Metropolis-Hasting [26,27]. The Monte Carlo algorithms are also applied to the inverse protein folding problem, which objective function is to find a sequence given a structure [51,52]. This paper focuses on the classical PFP that consists of finding the functional structure given a sequence aa.

The Rosetta is a protein structure prediction or de novo approach that performs models for the tertiary structure using the primary and secondary structure predictions. The algorithm generates a local sequence to produce local structures (fragments) that form a target protein template. Additionally, the fragments are then assembled by randomly using a Monte Carlo simulated annealing algorithm. Finally, the fitness of individual conformation interactions is evaluated based on a scoring function derived from known protein structures. However, only peptides longer than 27 aa can be provided as input [32].

Another PFP approach is I-TASSER (Iterative Threading ASSEmbly Refinement). It has four principal parts: generating a template using a multi-threading method, fragments’ assembly method, refinement process, final model selection, and annotation tools. The I-TASSER applies an alignment of the target sequence and divides it into aligned using LOMETS [53,54] and nonaligned regions using the Monte Carlo algorithm. In the last step, annotation of functions is performed based on the structural models obtained using the BioLIP [55] database of ligand-protein interactions. Finally, the I-TASSER predicts protein structures from 10 to 1500 amino acids [31].

PEP-FOLD3 has a framework to predict the tertiary structure of peptides using de novo structure modeling. The process of predicting structure consists of three stages. Firstly, for a peptide amino acid sequence, a support vector machine is applied to predict the structural alphabet of fragments. Secondly, several models are generated using series of states and refined by a Monte Carlo algorithm. Finally, the five best conformations are selected [28].

Another approach is QUARK [33], in which an ab initio strategy is used to predict protein structures in ranges of 20 to 200 aa. Additionally, an assembly process of fragments with small structures is carefully selected and applied in the target sequence using a Monte Carlo algorithm.

SAINT2 is a fragment-based de novo structure prediction approach that has been successfully compared with the CASP12 approaches [56], which consists of a sequence-to-structure pipeline divided into four principal sections: (a) the secondary structure prediction where PSI-PRED [57] is applied, (b) the torsion angles prediction using SPINE-X [58], (c) a fragment library with the Flib package, and (d) the residue-residue contact prediction applying metaPSICOV [59]. Finally, the highest-scoring model is selected. In our methodology, sections (a) and (b) are applied, and they are shown in Figure 1.

The GRSA Family Algorithms

The SA algorithm is inspired by the physical annealing process of metals [60,61]. The algorithm has been applied with success in many NP-hard problems [20], including the PFP. SA employs the Metropolis algorithm to efficiently explore the solution space and obtain a good solution to optimization problems. We show the pseudocode of SA in Algorithm 1. T_i and T_f parameters define the initial and final temperatures, respectively; the α parameter represents the cooling factor. In the Metropolis cycle, new solutions are generated by a perturbation function. Finally, to accept or reject a new solution, an acceptance criterion based on Boltzmann distribution is applied (lines 11–14). The SA algorithm is executed until the final temperature, T_f, is reached. The SA algorithm source code is available at https://github.com/DrJuanFraustoSolis/SimulatedAnnealing.git (accessed on 28 April 2021).

Algorithm 1. SA algorithm Procedure.

However, when the solution space is very large, the algorithm’s exploration takes a long time to obtain optimal solutions. Thus, new algorithms are necessary. The GRSA algorithm was proposed, which has been successfully applied in different NP problems [62,63], including the PFP [18]. The main characteristics of GRSA are the cooling scheme that decreases according to T_fp temperature cuts calculated by the golden number (ɸ) and then a stop criterion that reduces the cost of exploration (Algorithm 2). GRSA has a similar structure to the SA algorithm (lines 4 to 16). The difference with SA is that the GRSA calculates T_fp temperature cuts (five cuts are recommended), and in each cut, an $\mathsf{\alpha }$ parameter in the range [0.7, 1] is associated (the common higher value is 0.95); the intermediate $\mathsf{\alpha }$ values in this range are determined with an increment δ which represent the $\mathsf{\alpha }$ increment since the lowest until the highest $\mathsf{\alpha }$ value (in this case, $\mathsf{\delta }=0.05$). These alpha values are associated with each temperature cut (line 17). The algorithm reduces the temperature cooling speed; thus, the execution time, corresponding to lines 18 to 23, decreases. Finally, to reduce wasting time in low temperatures, where the quality of the result is not improved, a stop criterion was implemented using the least-squares method (lines 24 to 29). This stop criterion detects the stochastic equilibrium for some $i$ Metropolis cycles. We measure the slope (m is a global variable) of the linear regression of the energy of these cycles. In this regression, we used the coordinates ($E_i, i$); where $i$ is in the range [2, κ_max]. In our case, we used κ_max = 5. The equilibrium is found when m is close to zero, calculated by (2).

$$m=\frac{\kappa {{\displaystyle \sum }}_{i=2}^{\kappa }i{E}_i-\left({{\displaystyle \sum }}_{i=2}^{\kappa }i\right)\left({{\displaystyle \sum }}_{i=2}^{\kappa }{E}_i\right)}{\kappa {{\displaystyle \sum }}_{i=2}^{\kappa }{i}_{}^2-{\left({{\displaystyle \sum }}_{i=2}^{\kappa }i\right)}^2}$$

(2)

The Equation (2) can be written as follows (3):

$$m=\frac{12{{\displaystyle \sum }}_{i=2}^{\kappa }i{E}_i-6\left(\kappa -1\right)\left({{\displaystyle \sum }}_{i=1}^{\kappa }{E}_i\right)}{{\kappa }^3-\kappa }$$

(3)

where: $\kappa$ is the number of metropolis cycles for measuring the slope, i is the iteration of every metropolis cycle, and E_i the energy in each iteration.

The evaluation of m in Equation (2) does not imply a significative execution time; the summations on Equation (3) are only cumulative operations in Algorithm 3. This algorithm determines the equilibrium with this Equation (3). The GRSA algorithm source code is available at https://github.com/DrJuanFraustoSolis/GRSA.git (accessed on 28 April 2021).

Algorithm 2. GRSA algorithm Procedure.

Algorithm 3. Equilibrium Function.

The EGRSA (Algorithm 4) is an algorithm integrated by the hybridization of GRSA with evolutionary techniques. This algorithm has an evolutionary perturbation (EGRSApert) in the GRSA phase (line 7), where a genetic algorithm is used. The EGRSA algorithm starts with a set of individuals generated for determining the initial solution designed as S_i. Then in the Metropolis Cycle, the S_i is perturbated by EGRSApert to generate new solutions. Next, the best individual generated S_j solution is selected of the population (lines 9 and 10). EGRSA is similar to GRSA, and both applied a stop criterion (see Algorithm 2.1) by the least-squares method [64,65] (lines 24–29). Algorithm 5 presents EGRSApert function, where one individual is a set of dihedral angles [ɸ₁, Ψ₁, Χ₁, ω₁, ɸ₂, Ψ₂, Χ₂, ω₂, …, ɸ_n, Ψ_n, Χ_n, ω_n] and a population is a set of individuals. Then crossover and mutation operators are applied to generate new solutions by the perturbation function. Finally, when the number of generations is reached, the best individual of the population is selected. The EGRSA algorithm source code is available at https://github.com/DrJuanFraustoSolis/EGRSA.git (accessed on 28 April 2021).

Algorithm 4. EGRSA algorithm Procedure.

Algorithm 5. EGRSApert Function.

The GRSA2 algorithm [23] is a hybridization of GRSA with the CRO algorithm [66]. GRSA2 (Algorithm 6) is an enhancement of GRSA. It has the same structure as the previous algorithms revised in this paper. Specifically, GRSA2 has two principal differences in the perturbation phase, applying decomposition and soft collision (line 8) and the acceptance criterion (lines 10 to 14). In Algorithm 7, we show the perturbation process implemented in the GRSA2pert function. In GRSA2, two soft collisions are used (unimolecular, Intermolecular). This algorithm has been applied only in the PFP with a set of 19 peptides and compared with I-TASSER and PEP-FOLD3 approaches obtaining outstanding results in the case of peptides [23]. The GRSA2 algorithm source code is available at https://github.com/DrJuanFraustoSolis/GRSA2.git (accessed on 28 April 2021).

Algorithm 6. GRSA2 algorithm Procedure.

Algorithm 7. GRSA2pert Function.

3. GRSA-SSP Methodology

In this section, we present the GRSA-SSP methodology (Figure 1). This methodology has two main processes:

(a)

The prediction of the torsion angles (initial solution) from the secondary structure; that corresponds to stages 1 to 4 in Figure 1.

(b)

The refinement of the solution obtained from the secondary structure. This is performed with GRSA algorithms showed in stage four (Figure 1).

The GRSA-SSP methodology has an input (amino acid sequence), an output (tertiary structure prediction), and four stages: (1) secondary structure prediction, (2) torsion angles prediction, (3) template construction, and (4) refinement by GRSAX algorithms. Next, we explain each of these stages:

Input (Amino acid sequence). The amino acid sequences are taken as input.

(1)

Secondary structure prediction. This secondary structure, which corresponds to the amino acid sequence and is predicted using PSI-PRED [57]. This algorithm generates a sequence profile with PSI-BLAST [67] and performs the prediction of the stage, such as the helix (H), strand (E), and coil (C). PSI-PRED calculates the probability of each possible state and defines the most likely structure.

(2)

Torsion angles prediction. The secondary structure’s prediction is essential for this stage, where SPINE-X is used to obtain the torsion angles (ɸ, Ψ, and ω) of each amino acid. This process is realized through the Position-Specific Score Matrix and Physical Parameters [58]. SPINE-X applies artificial neural networks to obtain the best predictions of the target’s proteins.

(3)

Model construction. In this stage, the torsion angles or variables are used to construct a template as initial solution S_i = [ɸ₁, Ψ₁, Χ₁, ω₁, ɸ₂, Ψ₂, Χ₂, ω₂, …, ɸ_n, Ψ_n, Χ_n, ω_n] that is represented by amino acids subscript 1 to n and the same form by the following amino acids up to n; n is dependent on the size of an amino acid sequence of the target protein. The torsion angles represent the base column of the peptide on which the refinement will be performed.

(4)

Refinement by GRSAX. When the previous stages construct the peptide template, we can apply a GRSAX algorithm such as GRSA (renamed GRSA1), EGRSA (renamed GRSAE), and GRSA2, as well as the classical SA (GRSA0). The GRSAX algorithms are tested individually for comparison, which obtains a better tertiary structure of the target peptide. Moreover, once the energy and three-dimensional structure is obtained, the structure is evaluated with the RMSD and TM-score [29] metrics.

Output. The GRSAX-SSP algorithm obtains the tertiary structure prediction.

4. Results

We performed the next GRSAX-SSP algorithms with the proposed methodology: (a) GRSA0-SSP using classical SA [19], (b) GRSA1-SSP using original GRSA [21], (c) GRSAE-SSP using EGRSA [22], and (d) GRSA2-SSP using GRSA2 [23]. For all of them, we used the methodology presented in Figure 1. The peptides in this experimentation have 9 to 49 amino acids. The number of variables (torsion angles) for each peptide in this data set is in the range [49, 304]. We chose this set because these instances (peptides) were used before in the literature. This set was also useful for comparing the GRSA2-SSP algorithm with the top-performing approaches of the CASP, which can be used for small peptides. We compared the last algorithm with I-TASSER, PEP-FOLD3, QUARK, and Rosetta, which are among the best algorithms in the CASP competition. We noted a difference between the GRSAX-SSP algorithms and the one that only applies ab initio by naming it GRSAX.

Table 1. Set of instances (peptides).

N°	PDB-Code	aa	Number of Variables (Torsion Angles)	N°	PDB-Code	aa	Number of Variables (Torsion Angles)
1	1uao	10	47	24	1wz4	23	123
2	1egs	9	49	25	1rpv	17	124
3	1eg4	13	61	26	1pef	18	124
4	1l3q	12	62	27	1du1	20	134
5	2evq	12	66	28	1pei	22	143
6	1le1	12	69	29	1yyb	27	160
7	1in3	12	74	30	1t0c	31	163
8	3bu3	14	74	31	1by0	27	193
9	1gjf	14	79	32	2bn6	33	200
10	1rnu	13	81	33	1wr4	36	206
11	1lcx	13	81	34	1yiu	37	206
12	1k43	14	84	35	2ysh	40	213
13	1a13	14	85	36	1bhi	38	216
14	1nkf	16	86	37	1i6c	39	218
15	1le3	16	91	38	1wr7	41	222
16	1pgbF	16	93	39	2dmv	43	229
17	1dep	15	94	40	1bwx	39	242
18	1niz	16	97	41	1f4i	45	276
19	2bta	15	100	42	1dv0	47	279
20	1l2y	20	100	43	1ify	49	290
21	1e0q	17	109	44	2p81	44	295
22	1b03	18	109	45	1pgy	47	304
23	1wbr	17	120	-	-	-	-

presents the set of 45 instances sorted by the number of variables taken from [23,28,68,69] and a PDB code represents each peptide.

In the experimentation, the GRSAX-SSP algorithms were executed 30 times to validate the results. The energy function ECEPP/2 is determined with SMMP framework [38]; it is the objective function of our optimization algorithms. An analytical tuning [20] was performed to obtain the initial and final temperature for each instance. In GRSA0-SSP the α value is 0.95, and the temperature range has zero golden sections. For GRSA1-SSP, GRSAE-SSP, and GRSA2-SSP algorithms, the same cooling scheme was used, using the α parameter with values from 0.75 to 0.95 with five golden ratio sections, which was determined by experimentation [21,22,23]. The GRSAX-SSP algorithms were executed in one of the terminals of the Ehecatl cluster in TecNM/IT Ciudad Madero, and it has the following characteristics: Intel^® Xeon^® processor at 2.30 GHz, Memory: 64 GB (4 × 16 GB) ddr4-2133, Linux CentOS operating system, and Fortran language.

We used the minimum energy quality values, the RMSD, and TM-score to evaluate the results, which are two metrics of the structural quality used for PFP algorithms. The RMSD is a structural measure between the native structure and the one predicted by the GRSAX-SSP and classical SA named here as GRSA0:

(a)

If the RMSD has a value close to zero, the quality of the structure is considered excellent. On the contrary, the quality is worse.

(b)

The TM-score is also used to measure the similarity between two structures. When the TM-score is greater than 0.5, it indicates that there is a good similarity between the two structures, and the tested one has the same fold. Otherwise, as the TM-score is lower than 0.5, the target peptide has a different fold [29].

The TM-score metrics can be calculated using the TM-align [70] (an algorithm to obtain the best structural alignment between two proteins) or in a classical formulation [29]. In this paper, we use the classical formulation of TM-score.

GRSAX-SSP algorithms use a model determined by the secondary structure, and then it is refined for obtaining a better prediction. The results are compared with the GRSAX based on ab initio that only uses the amino acid sequence as information. Figure 2, Figure 3, Figure 4 and Figure 5 show average results related to energy (kcal/mol), RMSD, and TM-score for each peptide. The numbers in the x-axis, represent the instances or peptides of Table 1, and each instance is a set of torsional angles X = [ɸ₁, Ψ₁, Χ₁, ω₁, ɸ₂, Ψ₂, Χ₂, ω₂, …, ɸ_n, Ψ_n, Χ_n, ω_n] associated to each amino acid. We averaged the results of 30 executions for comparison.

Figure 2 shows that GRSA0-SSP has better behavior than GRSA0 or classical SA. Note that in all the peptides, GRSA0-SSP obtained the lowest energy. In other cases, the RMSD is more stable with small instances (1–16), and in the next instances, the behavior is equal. Additionally, when we compared with TM-score, the behavior, in general, is similar. In conclusion, by implementing this methodology in GRSA0-SSP with these instances, we obtained slightly improved results.

Figure 3 presents the comparison of the GRSA1-SSP versus GRSA1 with the same metrics; we observed the behavior with the 45 instances evaluated. In terms of energy, RMSD, and TM-score, the performance of GRSA1-SSP is equivalent to GRSA1.

Figure 4 shows the behavior of GRSAE-SSP, and we compared it with the original GRSAE algorithm. In this figure, we can appreciate that the results are equivalent in all cases when energy, RMSD, and TM-score are used for comparison.

In Figure 5, we present the comparison of GRSA2 versus GRSA2-SSP. Note that the results obtained in every instance are very remarkable, and the superiority of GRSA2-SSP uses the metrics of energy, RMSD, and TM-Score. In this case, we applied the methodology GRSA-SSP to improve the behavior of the classical GRSA2 algorithm.

Finally, in Figure 6, we present the comparison of the GRSAX-SSP family algorithms. We observe that GRSA2-SSP has the best values in several instances against the other algorithms, being higher than the others. Therefore, the best behavior of the algorithms with secondary structure prediction is GRSA2-SSP.

Furthermore, Figure 7 presents the computational time of the GRSAX-SSP family algorithms. The GRSA2-SSP has the best behavior in time with low values in most of the instances compared to the other algorithms.

Table 2. Results obtained by GRSA2-SSP.

N°	PDB Code	aa	SS	RMSD	RMSD Ave	RMSD std	TM1 Best	TM1 Ave	TM1 std	N°	PDB Code	aa	SS	RMSD	RMSD Ave	RMSD std	TM1 Best	TM1 Ave	TM1 std
1	1egs	9	N	1.47	0.728	0.737	0.411	0.3630	0.043	24	1pef	18	A	1.5	0.706	0.468	0.686	0.661	0.014
2	1uao	10	B	0.71	1.214	0.828	0.401	0.375	0.022	25	1l2y	20	A	0.77	2.268	0.914	0.258	0.243	0.008
3	1l3q	12	N	1.55	1.486	0.727	0.271	0.252	0.025	26	1du1	20	A	1.13	1.62	0.463	0.266	0.266	0.001
4	2evq	12	B	2.43	1.274	1.020	0.382	0.318	0.031	27	1pei	22	A	2.02	1.43	0.366	0.379	0.364	0.010
5	1le1	12	B	0.38	1.356	1.208	0.316	0.301	0.011	28	1wz4	23	A	2.66	2.66	0.424	0.272	0.265	0.015
6	1in3	12	A	1.07	1.054	0.341	0.395	0.387	0.007	29	1yyb	27	A	1.47	1.75	0.306	0.397	0.395	0.002
7	1eg4	13	N	1.59	1.632	0.397	0.339	0.330	0.006	30	1by0	27	A	1.16	1.44	0.217	0.413	0.408	0.003
8	1rnu	13	A	0.26	0.288	0.033	0.628	0.616	0.010	31	1t0c	31	N	2.73	3.04	0.344	0.216	0.2	0.009
9	1lcx	13	N	1.08	1.412	0.422	0.334	0.323	0.009	32	2bn6	33	A	2.17	2.33	0.22	0.329	0.319	0.010
10	3bu3	14	N	1.02	1.122	0.47	0.294	0.263	0.019	33	1wr4	36	B	3.18	3.09	0.55	0.243	0.21	0.018
11	1gjf	14	A	1.37	0.874	0.461	0.561	0.547	0.040	34	1yiu	37	B	3.01	3.17	0.455	0.221	0.202	0.011
12	1k43	14	B	2.92	1.488	0.916	0.303	0.261	0.027	35	1bhi	38	N	2.76	2.736	0.794	0.306	0.296	0.007
13	1a13	14	N	1.38	1.29	0.126	0.313	0.302	0.007	36	1i6c	39	B	4.29	3.51	0.505	0.205	0.191	0.010
14	1dep	15	A	0.98	0.762	0.352	0.641	0.603	0.023	37	1bwx	39	A	2.98	2.58	0.282	0.451	0.443	0.005
15	2bta	15	N	2.47	1.716	0.455	0.227	0.196	0.018	38	2ysh	40	B	3.21	3.46	0.493	0.243	0.222	0.016
16	1nkf	16	A	3.03	1.838	0.842	0.287	0.278	0.009	39	1wr7	41	B	3.71	3.55	0.146	0.223	0.208	0.011
17	1le3	16	B	1.02	1.25	0.77	0.224	0.215	0.007	40	2dmv	43	B	3.27	3.402	0.6	0.217	0.201	0.013
18	1pgbF	16	B	1.54	2.03	0.409	0.229	0.209	0.018	41	2p81	44	A	3.52	3.21	0.476	0.185	0.178	0.007
19	1niz	16	B	2.4	1.77	0.572	0.235	0.214	0.016	42	1f4i	45	A	3.13	3.46	0.221	0.31	0.302	0.006
20	1e0q	17	B	0.79	1.494	0.536	0.226	0.221	0.008	43	1dv0	47	A	2.65	2.94	0.437	0.303	0.283	0.011
21	1wbr	17	N	1.68	1.31	0.363	0.295	0.2716	0.016	44	1pgy	47	A	3.22	2.62	0.46	0.345	0.336	0.006
22	1rpv	17	A	0.81	0.71	0.096	0.469	0.463	0.005	45	1ify	49	A	2.56	2.77	0.4	0.311	0.297	0.008
23	1b03	18	B	3.04	2.356	0.629	0.2143	0.208	0.004	-	-	-	-	-	-	-	-	-	-

Note: PDB code (Instance), number of amino acids (aa), SS is the predominant secondary structure type: beta strand (B), alpha-helix (A) and none (N), TM¹ = TM-score.

presents the results obtained by GRSA2-SSP. For each instance, we show the best TM-score and their RMSD. Additionally, we calculated the average of the RMSD and TM-score for the five best predictions. Complementing the results, we determined the standard deviation (std) of the RMSD and TM-score for the five best predictions and included the best type of secondary structure: A (mainly alpha), B (mainly beta), and N (mainly none). This classification as A, B, and N is based on the secondary structure predominating in each peptide [27,68,69,71,72]. We sort Table 2 by the number of amino acids for comparing the best results obtained by GRSA2-SSP with the best algorithms of the literature. This comparison is presented in Figures 9–11.

Figure 8 shows the GRSA2-SSP algorithm performance with instances classified by secondary structure. We show that the GRSA2-SSP algorithm has the best behavior in alpha structure instances evaluated with TM-score in Figure 8a and RMSD metrics in Figure 8b. The values in Figure 8 are the best obtained using TM-score and their RMSD. In Figure 8c,d, we present the TM-score average for the five best predictions and their RMSD average.

In Figure 9, Figure 10 and Figure 11, we present the behavior of the GRSA2-SSP algorithm, and we compare it with the results obtained from the approaches PEP-FOLD3, I-TASSER, QUARK, and Rosetta. We divided the dataset of Table 1 into three groups of 15 instances; groups 1, 2, and 3 have instances 1–15, 16–30, and 31–45. We compared these groups using the metrics RMSD, TM-score, GDT-TS [73], and TM-score (classical), and we present the best TM-score, the average of the five best predictions of the TM-score, and their RMSD. Additionally, we present the GDT-TS average and TM-score average.

In Figure 9, we introduced the comparison of the first group, and we observed that GRSA2-SSP behaves similarly to I-TASSER and PEP-FOLD3, but in this group of small peptides, PEP-FOLD3 is slightly better than our algorithm and I-TASSER when GDT-TS is compared (Figure 9e). Furthermore, we observed that our algorithm is competitive in this group. In this comparison, Rossetta and QUARK were not added because the minimal number of amino acids predicted are 27 and 20, respectively.

Figure 10 compares the second group of 16 to 30 amino acids with the best and the five best obtained using the TM-score metric and their RMSD, and the GDT-TS average. In this comparison, we added the second group of instances’ results of QUARK; Rosetta was omitted because it is unable to predict most of the instances of this group.

In Figure 10a we observe very similar behavior among GRSA2-SSP, PEP-FOLD3, I-TASSER, and Rosetta. Note in this figure, GRSA2-SSP and PEP-FOLD3 obtain the best prediction. In Figure 10c, when the best five predictions are compared, I-TASSER obtains the best results, followed by PEPFOLD3 and GRSA2-SSP. Additionally, when the RMSD average is compared (Figure 10d), I-TASSER is the best, followed by PEP-FOLD3 and GRSA2-SSP. Finally, in Figure 10e, when GDT-TS is compared, GRSA2-SSP has a similar performance to PEP-FOLD3, I-TASSER, and QUARK. According to this figure, GRSA2-SSP and I-TASSER obtained a similar average.

Figure 11 compares the third group of 31 to 49 amino acids with the five best results obtained using the TM-score metric and their RMSD y GDT-TS. This comparison added the Rosetta approach because it can process the number of aa in this group. As we observe, the best algorithm is I-TASSER, followed by Rosetta, QUARK, PEP-FOLD3, and finally GRSA2-SSP.

The 45 instances evaluated in the below experimentation show the application of the secondary structure results and refine them with the GRSAX algorithms, enhancing the performance in energy, RMSD, and TM-score. Specifically, when GRSA2-SSP is compared with PEP-FOLD3, I-TASSER, QUARK, and Rosetta, we observed that our algorithm performs well in small instances (Group 1 and 2). Nevertheless, in the largest instances, our algorithm is not the best, but it is competitive.

We carried out a second experimentation with six mini-proteins (5wll, 5lo2, 5up5, 5uoi, 2ki0, and 2kik) presented in

Table 3. Mini-proteins.

Instances
N°	PDB Code	aa	Number of Variables (Torsion Angles)	SS
1	5wll	26	174	A
2	5lo2	34	192	A
3	2ki0	36	214	N
4	5up5	40	266	N
5	5uoi	43	282	A
6	2kik	48	306	A

Note: alpha-helix (A) and none (N) for secondary structure.

. The mini-proteins come from the de novo protein design field [74,75,76,77,78]. This data set was proposed to observe the behavior of our best algorithm in these kinds of instances.

We applied the same evaluation of all the algorithms, as in the first experimentation, using RMSD, TM-score, and GDT-TS metrics.

Table 4. Average metrics results of Mini-proteins.

Approaches	Instances
	5wll			5lo2			2ki0
	RMSD	TM-Score	GDT-TS	RMSD	TM-Score	GDT-TS	RMSD	TM-Score	GDT-TS
GRSA2-SSP	0.656 *	0.642 *	0.944 *	1.504 *	0.501	0.649	2.172	0.354	0.504
PEP-FOLD3	1.074	0.526	0.892	1.922	0.532	0.769	2.422	0.466	0.697
I-TASSER	0.823	0.530	0.737	1.734	0.608	0.776	0.620 *	0.899 *	0.986 *
QUARK	0.897	0.565	0.788	1.848	0.527	0.713	2.228	0.450	0.688
Rosetta	N/A	N/A	N/A	1.552	0.694 *	0.849 *	2.146	0.460	0.710
Approaches	Instances
	5up5			5uoi			2kik
	RMSD	TM-Score	GDT-TS	RMSD	TM-Score	GDT-TS	RMSD	TM-Score	GDT-TS
GRSA2-SSP	2.234	0.277	0.403	3.194	0.192	0.340	2.756	0.339	0.508
PEP-FOLD3	2.512	0.372	0.541	2.516	0.481	0.629	2.282	0.395	0.597
I-TASSER	1.390 *	0.782 *	0.900 *	2.565	0.512	0.664	2.187	0.448	0.557
QUARK	1.880	0.614	0.778	2.022	0.633	0.777	2.028	0.462	0.627
Rosetta	1.716	0.692	0.838	1.642 *	0.753 *	0.871 *	1.968 *	0.665 *	0.785 *

Note: The asterisk (*) represents the best result in each column.

shows the results of all the algorithms in this data set. Evaluating them with TM-score and GDT-TS, we observe that the best algorithms were Rosetta, I-TASSER, and GRSA2-SSP, where the number of times the best results were achieved 3, 2, and 1, respectively. Additionally, evaluating with the RMSD, the best algorithms were again Rosseta, I-TASSER, and GRSA2-SSP, but this time they obtained the best results in two instances, which were (5uoi, 2kik), (2ki0, 5up5), and (5wll, 5lo2), respectively. As a result, we can say that Rosetta is the best algorithm, followed by I-TASSER, and GRSA2-SSP.

5. Conclusions

In this paper, we present the methodology GRSA-SSP for Protein Folding Problem applied to peptides. The objective of this problem is to predict the functional tridimensional protein structure. The algorithms developed with this methodology are GRSA0-SSP, GRSA1-SSP, GRSAE-SSP, and GRSA2-SSP. The main relevance of the algorithm GRSA2-SSP, developed with this methodology, is that it produces very good results in the case of peptides; specifically, it is similar or better than the algorithms Rosetta, PEP-FOLD3, QUARK, and I-TASSER for the small and medium peptides, according to the experimentation presented. The last algorithms have traditionally been among the best of the CASP competition; besides, they use modern machine learning techniques like artificial neural networks.

We compared the algorithms developed with the original algorithms GRSA0, GRSA1, GRSAE, and GRSA2; we used a data set of 45 instances for this comparison. We showed that the hybrid algorithms produced with the GRSA-SSP methodology outperform the original ones. For this comparison, we used the metrics Energy, RMSD, TM-score, and execution time. We observed that the best of all these algorithms is GRSA2-SSP formulated with the proposed methodology.

We made a second evaluation comparing the GRSA2-SSP algorithm with the best state-of-the-art algorithms (we used the same data set of 45 instances). We selected for this comparison PEP-FOLD3, I-TASSER, QUARK, and Rosetta. We used a data set of forty-five instances divided into three groups, from small to large peptides. The experimentation shows that for groups 1 and 2, GRSA2-SSP performs as well as these algorithms. We observe that for the first group PEP-FOLD3 was the best, followed by GRSA2-SSP, while in the second group, the best algorithm was I-TASSER followed by GRSA2-SSP and PEP-FOLD3. Finally, in the third group, the best algorithm was Rosseta, followed by I-TASSER. Additionally, we present an analysis of GRSA2-SSP results for each type of secondary structure, obtaining a better behavior with alpha structures.

Furthermore, we assessed GRSA2-SSP with a second data set of six instances named mini proteins. The GRSA2-SSP results were compared with PEP-FOLD3, I-TASSER, QUARK, and Rosetta. The best algorithms in this data set were Rosetta, I-TASSER, and GRSA2-SSP because the number of times the best TM-score and GDT-TS were 3, 2, and 1, respectively. However, each of the three achieved two times the first place when RMSD was evaluated. As a result, the best of these algorithms for this data set is Rosetta, followed by I-TASSER and GRSA2-SSP.

We conclude that GRSAX-SSP algorithms enhance the original GRSA algorithms. The best of them is GRSA2-SSP which achieves very good results, surpassing the best state-of-art for peptides up to thirty amino acids. Finally, we note that the main advantage of our methodology is that it is simpler than the most powerful approaches of the literature.